Adding aspect-oriented features to MATLAB

This paper presents an approach to enrich MATLAB with aspect-oriented extensions to experiment different implementation features. The language we propose aims to configure the low-level data representation of real variables and expressions, to a specifically-tailored fixed-point data representation that benefits from a more efficient support by computing engines (e.g., DSPs, application-specific architectures, etc.) without specific hardware-based floating point units. Additionally, the approach aims to help developers to introduce handlers and monitoring features, and to configure a function with an optimized implementation.FCT under projects PPC-VM (POSI/CHS/47158/2002) and SOFTAS (POSI/EIA/ 60189/200

C++ é inadequado para ensinar OO

Num curso superior de Informática não deve haver preocupação em ensinar a última novidade tecnológica, mas antes os fundamentos que permitam aos diplomados uma capacidade para aprender continuamente. No ensino da programação orientada ao objecto (POO) é importante utilizar-se uma linguagem com suporte coerente dos conceitos fundamentais do paradigma, sem características que entrem em contradição com o modelo central, sob pena da linguagem se tornar um obstáculo à aprendizagem. Neste artigo argumenta-se precisamente que C++ é um obstáculo à aprendizagem da POO. Muitos alunos acreditam que aprender C++ lhes dará todas as competências na área da programação de que necessitarão no futuro. Esta visão errada tem como consequência que poderão ficar pior preparados para se adaptarem às mudanças a que a informática está sujeita. C++ foi criado tendo em vista a compatibilidade com o C, pelo que todas as decisões de concepção do C++ estiveram dependentes das características, boas ou más, da linguagem anterior. Só este facto já permite questionar se tudo o que o C++ oferece será coerente, sobretudo se se considerar que o próprio C, por vezes classificado de “linguagem assembly estruturada”, dá suporte a vários paradigmas da programação. Na verdade C++ não é uma linguagem orientada ao objecto (LOO), mas uma linguagem multiparadigma, dotada dum suporte imperfeito dos conceitos da OO, misturados com conceitos oriundos de modelos de programação mais antigos. A seguir alude-se a alguns dos principais aspectos técnicos em que C++ apresenta imperfeições no suporte à POO. São feitas comparações com algumas das LOOs mais importantes, sobretudo Eiffel e Java

An illustrative example of refactoring object-oriented source code with aspect-oriented mechanisms

This paper describes a refactoring process that transforms a Java source code base into a functionally equivalent AspectJ source code base. The process illustrates the use of a collection of refactorings for aspect-oriented source code, covering the extraction of scattered implementation elements to aspects, the internal reorganization of the extracted aspects and the extraction of commonalities to super-aspects.Fundação para a Ciência e a Tecnologia (FCT)Fundo Europeu de Desenvolvimento Regional (FEDER) - POSC/EIA/60189/200

Some thoughts on refactoring objects to aspects

The prospect of aspect-orientation receiving widespread acceptance and adoption in the near future begs the question of how to deal with a large base of object-oriented legacy code. We propose to investigate refactoring techniques for restructuring object-oriented source code so that it can leverage the mechanisms of aspect-orientation in order to become easier to adapt, extend and evolve. Our approach is to adopt an object-oriented framework in the area of workflow as a non-trivial case study. We plan to analyse its source code, develop an aspect-oriented version through the progressive use of manual refactorings, and build a catalogue of refactoring operations based on the experience gained through the process

Pitfalls of aspectJ implementations of some of the gang-of-four design patterns

For the previous edition of this workshop [8], the authors wrote a paper presenting the aims of the first author’s Ph.D. project [13], which includes the development of a catalogue of refactorings [3] for the AspectJ programming language [1]. Case studies are be used for refactoring experiments, to gain the necessary insights. In this paper, we present several considerations on some code examples in AspectJ [10] from our second case study. They look like a critique, which may lead readers to assume we have a low opinion of them. That is not the case: we largely consider them a success, and proved to be a rich source of insights. Our intent is to simply point out some problems in using the code examples, thus contributing to their analysis. This is done in section 2. We take the opportunity provided by this paper to present, in section 3, an update on a style rule proposed in the previous paper [13]. In section 4 we conclude the paper.PRODEP III - Medida 5 - Acção 5.3 - Eixo 3 - Formação Avançada de Docentes do Ensino Superior; PPC-VM - POSI/CHS/47158/2002

Refactoring a java code base to aspectJ: an illustrative example

This paper describes a refactoring process transforming a Java code base into an AspectJ equivalent. The process illustrates 17 aspect-oriented refactorings covering extraction of implementation elements to aspects, internal reorganization of extracted aspects, and extraction of commonalities to superaspects.(undefined

Emotion-Focused Therapy for Depression

info:eu-repo/semantics/publishedVersio

A domain-specific aspect language for transforming MATLAB programs

Aspect-oriented programming provides powerful ways to augment programs with information out of the scope of the base language while avoiding harming code readability and thus portability. MATLAB is a popular modeling/programming language that will strongly benefit of aspect-oriented programming features. For instance, MATLAB programmers could use aspects to provide information such as restrictions on allowed data types and/or values, monitoring specific aspects of the execution such as the effective dataset sizes or if a given variable ever assumes a specific value, without “polluting” the code with “check code”. This paper describes the main concepts of a domain-specific aspect language (DSAL) for specifying transformations of MATLAB programs in view of supporting optimizations by facilitating the experimentation of alternative implementations. This DSAL specifies aspect modules structured in three sections: intersections equivalent to AspectJ poincuts, actions equivalent to AspectJ advice, and conditions that control triggering of actions. Support for aspect composition strategies and aspect parameterization of tokens from the base program are also supported. We believe the described features complement and enhance MATLAB programming in substantial and valuable ways